20:55:13  "Finalizer thread" Id=29 BLOCKED on java.lang.ref.ReferenceQueue@49d657dd owned by "Thread-11" Id=33
20:55:13  	at java.lang.ref.ReferenceQueue.enqueue(ReferenceQueue.java:179) // Acquire ReferenceQueue's monitor
20:55:13  	at java.lang.ref.Reference.enqueueImpl(Reference.java:147) // Acquire Reference's monitor
20:55:13  


20:55:13  "Thread-11" Id=33 BLOCKED on java.util.logging.LogManager$LoggerWeakRef@596d6465 owned by "Finalizer thread" Id=29
20:55:13  	at java.lang.ref.Reference.dequeue(Reference.java:195) // Acquire Reference's monitor
20:55:13  	at java.lang.ref.ReferenceQueue.poll(ReferenceQueue.java:85) // Acquire ReferenceQueue's monitor
20:55:13  	at java.util.logging.LogManager.drainLoggerRefQueueBounded(LogManager.java:1130)
20:55:13  	at java.util.logging.LogManager.addLogger(LogManager.java:1160)
20:55:13  	at java.util.logging.LogManager.demandLogger(LogManager.java:556)
20:55:13  	at java.util.logging.Logger.demandLogger(Logger.java:455)
20:55:13  	at java.util.logging.Logger.getLogger(Logger.java:502)
20:55:13  	at TestLogConfigurationDeadLock$AddLogger.run(TestLogConfigurationDeadLock.java:175)

public Reference<? extends T> poll () {
        Reference ref;

        /* Optimization to return immediately and not synchronize if there is nothing in the queue */
        if(empty) {
                return null;
        }
        synchronized(this) {
                if(empty) {
                        return null;
                }
                ref = references[head];
                references[head++] = null;
                if(head == references.length) {
                        head = 0;
                }
                if(head == tail) {
                        empty = true;
                }
        }
        ref.dequeue(); // Moved outside the synchronized block
        return ref;
}

public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException {
        if (timeout < 0) throw new IllegalArgumentException();

        Reference ref;
        synchronized(this) {
                if(empty) {
                        wait(timeout);
                        if(empty) return null;
                }
                ref = references[head];
                references[head++] = null;
                if(head == references.length) {
                        head = 0;
                }
        }
        ref.dequeue(); // Moved outside the synchronized block
        synchronized(this) { // Not sure if it matters to notifyAll() after invoking dequeue()
                if(head == tail) {
                        empty = true;
                } else {
                        notifyAll();
                }
        }
        return ref;
}

public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException {
        if (timeout < 0) throw new IllegalArgumentException();

        Reference ref;
        boolean notifyAll = true;
        synchronized(this) {
                if(empty) {
                        wait(timeout);
                        if(empty) return null;
                }
                ref = references[head];
                references[head++] = null;
                if(head == references.length) {
                        head = 0;
                }
                if(head == tail) {
                        empty = true;
                        notifyAll = false;
                }
        }
        ref.dequeue(); // Moved outside the synchronized block
        if (notifyAll) {
                synchronized(this) {
                        notifyAll();
                }
        }
        return ref;
}